home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt40s3.arc / PIBTDCL2.GLO < prev   
Text File  |  1987-08-30  |  46KB  |  1,031 lines
  1. {.C-}
  2. (*----------------------------------------------------------------------*)
  3. (*              Definitions for Kermit protocol transfers               *)
  4. (*----------------------------------------------------------------------*)
  5.  
  6. CONST
  7.    MaxKermitWindowSize     = 31;
  8.    MaxLongPacketLength     = 1000;
  9.  
  10. TYPE
  11.    Kermit_Packet_Buffer     = ARRAY[1..94] OF CHAR;
  12.    Kermit_Packet_Ptr        = ^Kermit_Packet_Buffer;
  13.  
  14.    Kermit_State_Vars = ( Send_Init,      Send_File_Header,  Send_File,
  15.                          Send_EOF,       Send_Break,        Receive_Init,
  16.                          Receive_Header, Receive_File,      Send_Bye,
  17.                          Get_File );
  18.                          
  19.    Kermit_File_Param   = ( Kermit_Ascii, Kermit_Binary, Kermit_None );
  20.    
  21.    Kermit_Packet_Param = ( Break_Pack,  Data_Pack, Error_Pack,
  22.                            Header_Pack, NAK_Pack,  Send_Pack, Reserved_Pack,
  23.                            ACK_Pack,    End_Pack,  Generic_Pack,
  24.                            Text_Pack,   Host_Pack, Attrib_Pack, Unknown );
  25.  
  26.    Kermit_File_Modes   = ( Read_Open, Write_Open );
  27.  
  28.    Kermit_Window_Type_Record = RECORD
  29.                                   Data_Slot   : INTEGER;
  30.                                   Data_Length : INTEGER;
  31.                                   ACK_Flag    : BOOLEAN;
  32.                                   Retry_Count : INTEGER;
  33.                                END;
  34.  
  35.                                    (* Window packet queue       *)
  36.  
  37.    Kermit_Window_Queue_Type = ARRAY[0..63] OF Kermit_Window_Type_Record;
  38.                               
  39.    Kermit_Abort_Type         = (No_Abort, One_File, All_Files, Entire_Protocol);
  40.    
  41. VAR
  42.                                    (* Type of file (Ascii, Binary) *)
  43.                                    
  44.    Kermit_File_Type_Var : Kermit_File_Param;
  45.  
  46.                                    (* Type of current Kermit packet *)
  47.  
  48.    Kermit_Packet_Type   : Kermit_Packet_Param;
  49.  
  50.                                    (* Current state of Kermit transfer *)
  51.  
  52.    Kermit_State         : Kermit_State_Vars;
  53.  
  54.                                    (* If remote kermit in server mode *)
  55.    Kermit_Remote_Server : BOOLEAN;
  56.  
  57.    Kermit_Init_Packet_Size : INTEGER  (* Initial max packet size *);
  58.  
  59.    Kermit_Packet_Size   : INTEGER  (* Size of current packet *);
  60.    Kermit_Extended_Block: INTEGER  (* Max size of long block *);
  61.    Kermit_Timeout       : INTEGER  (* Timeout value in seconds *);
  62.    His_TimeOut          : INTEGER  (* Timeout desired by remote *);
  63.    Kermit_Npad          : INTEGER  (* Number of padding characters *);
  64.    Kermit_EOL           : CHAR     (* End of line character *);
  65.    Kermit_Header_Char   : CHAR     (* Block header character *);
  66.    
  67.    Kermit_Pad_Char      : CHAR     (* Padding character *);
  68.    Kermit_Quote_Char    : CHAR     (* Control-quote character *);
  69.    Kermit_Quote_8_Char  : CHAR     (* 8-bit quoting character *);
  70.    Kermit_Chk_Type      : CHAR     (* Block-check type        *);
  71.    Kermit_Repeat_Char   : CHAR     (* Repeat character        *);
  72.    Kermit_Handshake_Char: CHAR     (* Handshake character     *);
  73.    
  74.    
  75.    Packet_OK          : BOOLEAN    (* TRUE if packet OK        *);
  76.    Ack_OK             : BOOLEAN    (* TRUE if packet ACK'd     *);
  77.    Open_OK            : BOOLEAN    (* TRUE if file to transfer opened OK *);
  78.    File_Done          : BOOLEAN    (* TRUE if file being sent done *);
  79.    Kermit_Abort       : BOOLEAN    (* TRUE if keyboard entry aborts transfer *);
  80.    Kermit_Retry       : BOOLEAN    (* TRUE to retry current packet *);
  81.    Kermit_Really_Done : BOOLEAN    (* TRUE if Kermit protocol done *);
  82.    
  83.                                    (* Type of keyboard-originated abort *)
  84.                                    
  85.    Kermit_Abort_Level : Kermit_Abort_Type;
  86.    
  87.    Packet_Num         : INTEGER    (* Packet number being sent *);
  88.    Rec_Packet_Num     : INTEGER    (* Received packet number *);
  89.    Packets_Sent       : REAL       (* Number of packets sent *);
  90.    Packets_Received   : REAL       (* Number of packets received *);
  91.    Packets_Bad        : REAL       (* Number of errors in transfer *);
  92.  
  93.    File_Open          : BOOLEAN    (* TRUE if file being transferred is open *);
  94.    Quoting            : BOOLEAN    (* TRUE if 8th-bit quoting in effect *);
  95.    Repeating          : BOOLEAN    (* TRUE if repeating/compression in effect *);
  96.    Sending_File       : BOOLEAN    (* TRUE if uploading, FALSE if downloading *);
  97.    Logging_Out_Server : BOOLEAN    (* TRUE if logging out remote server       *);
  98.    
  99.    My_Pad_Char        : CHAR       (* Default pad character *);
  100.    His_Quote_Char     : CHAR       (* Remote kermit's quote character *);
  101.    His_Quote_8_Char   : CHAR       (* Remote kermit's 8th-bit quote character *);
  102.    His_Chk_Type       : CHAR       (* Remote kermit's block check type *);
  103.    His_Repeat_Char    : CHAR       (* Remote kermit's repeat quote char *);
  104.    
  105.    My_Pad_Num         : INTEGER    (* Default number of padding characters *);
  106.    Send_EOL           : INTEGER    (* Send CR first time *);
  107.    
  108.    File_Records       : REAL       (* Number of bytes in disk file *);
  109.    Buffer_Num         : REAL       (* How many characters read/written *);
  110.    Kermit_Delay_Time  : INTEGER    (* Time to wait before send in host mode *);
  111.    Receive_Done       : BOOLEAN    (* TRUE if file reception complete *);
  112.    Kermit_MaxTry      : INTEGER    (* Maximum number of retries allowed *);
  113.    Rec_Packet_Length  : INTEGER    (* Received packet data length *);
  114.                                    (* Points to received data     *)
  115.    Rec_Packet_Ptr     : Kermit_Packet_Ptr;
  116.    Send_Packet_Length : INTEGER    (* Send packet data length *);
  117.                                    (* Points to data to send  *)
  118.    Send_Packet_Ptr    : Kermit_Packet_Ptr;
  119.    
  120.    Kermit_Menu_Title  : AnyStr     (* Title for Kermit windows *);
  121.    
  122.    Finish_Kermit_Server : BOOLEAN  (* TRUE to stop remote server *);
  123.    Kermit_Debug         : BOOLEAN  (* TRUE if Kermit debug mode *);
  124.    
  125.    Kermit_Transfer_Start: REAL     (* Starting time of transfer *);
  126.    Kermit_Transfer_End  : REAL     (* Ending time of transfer   *);
  127.    Kermit_Transfer_Rate : REAL     (* Transfer rate in CPS      *);
  128.    
  129.    Kermit_Window_Size   : INTEGER  (* No. of packets in window  *);
  130.    Kermit_Window_Top    : BYTE     (* Top packet in window      *);
  131.    Kermit_Window_Bottom : BYTE     (* Bottom packet in window   *);
  132.  
  133.                                    (* Window packet queue       *)
  134.                                    
  135.    Kermit_Queue         : Kermit_Window_Queue_Type;
  136.    
  137. (*----------------------------------------------------------------------*)
  138. (*                    Global script file variables                      *)
  139. (*----------------------------------------------------------------------*)
  140.  
  141. CONST
  142.    Max_Script_File_Commands = 87       (* # of script commands              *);
  143.    MaxScripts               = 100      (* Maximum # of compiled scripts     *);
  144.    MaxScriptCalls           = 64       (* Maximum call depth within script  *);
  145.    MaxScriptVariables       = 100      (* Maximum variables each script     *);
  146.    MaxNestedScripts         = 10       (* Maximum nesting depth for scripts *);
  147.    MaxOperandTypes          = 10       (* Maximum # of script data types    *);
  148.    MaxWhenStrings           = 10       (* Maximum # of WHEN strings         *);
  149.    MaxWaitStrings           = 20       (* Maximum # of WAIT strings         *);
  150.    MaxScriptOpenFiles       = 10       (* Maximum # of open script files    *);
  151.    MaxNewCommands           = 100      (* Maximum # of new commands         *);
  152.    MaxScriptArgs            = 20       (* Maximum # of script arguments     *);
  153.    
  154. TYPE
  155.    OperandType =    ( Bad_Operand_Type, Operator_Type, Integer_Variable_Type,
  156.                       Real_Variable_Type, String_Variable_Type,
  157.                       Integer_Constant_Type, Real_Constant_Type,
  158.                       String_Constant_Type,
  159.                       StackEnd_Type, Left_Paren_Type, Right_Paren_Type,
  160.                       Comma_Type );
  161.                       
  162. VAR
  163.                                    (* Script conversion table       *)
  164.                                    
  165.    PibTerm_Command_Table_2 : ARRAY[0..No_Of_PibTerm_Commands_Minus_One]
  166.                              OF PibTerm_Command_Type;
  167.                              
  168. TYPE
  169.                                    (* Generic buffer type to hold script *)
  170.                                    
  171.    Script_Buffer_Type = ARRAY[1..1] OF BYTE;
  172.    
  173.                                    (* For pointing to start of script    *)
  174.                                    
  175.    Script_Buffer_Ptr  = ^Script_Buffer_Type;
  176.    
  177.                                    (* Script variable definition *)
  178.  
  179.    Script_Variable_Record   = RECORD
  180.                                  Var_Name   : String10;
  181.                                  Var_Type   : OperandType;
  182.                                  Var_Passed : BOOLEAN;
  183.                                  Var_Temp   : BOOLEAN;
  184.                                  Var_Value  : StringPtr;
  185.                               END;
  186.                               
  187.    Script_Variable_Record_Ptr = ^Script_Variable_Record;
  188.  
  189.                                    (* Saves variables across CALLs *)
  190.                                    
  191.    Script_Save_Variable_Record_Ptr = ^Script_Save_Variable_Record;
  192.    
  193.    Script_Save_Variable_Record = RECORD
  194.                                     Save_Data : Script_Variable_Record_Ptr;
  195.                                     Prev_Var  : Script_Save_Variable_Record_Ptr;
  196.                                  END;
  197.                                  
  198.                                    (* Script variable list *)
  199.                                    
  200.    Script_Variable_List     = ARRAY[0..MaxScriptVariables] OF Script_Variable_Record;
  201.    Script_Variable_List_Ptr = ^Script_Variable_List;
  202.    
  203.                                    (* Holds variable indices of parameters *)
  204.                                    
  205.    Script_Parameter_Vector = ARRAY[1..MaxScriptArgs] OF INTEGER;
  206.    Script_Parameter_Ptr    = ^Script_Parameter_Vector;
  207.    
  208.                                    (* Defines a script record *)
  209.    Script_Record_Type = RECORD
  210.                            Script_Name         : STRING[8];
  211.                            Script_Ptr          : Script_Buffer_Ptr;
  212.                            Script_Len          : INTEGER;
  213.                            Script_Vars_Count   : INTEGER;
  214.                            Script_Vars         : Script_Variable_List_Ptr;
  215.                            Script_Params_Count : INTEGER;
  216.                            Script_Params       : Script_Parameter_Ptr;
  217.                         END;
  218.                         
  219.                                    (* Saves stack of EXECUTEd scripts *)
  220.    Script_Buffer_Save = RECORD
  221.                            Script_Num  : INTEGER;
  222.                            Buffer_Pos  : INTEGER;
  223.                            Buffer_Ptr  : Script_Buffer_Ptr;
  224.                            Vars_Ptr    : Script_Variable_List_Ptr;
  225.                            Vars_Count  : INTEGER;
  226.                            Prev_Ptr    : Script_Variable_List_Ptr;
  227.                            Params_Ptr  : Script_Parameter_Ptr;
  228.                            Params_Count: INTEGER;
  229.                            Params_Got  : INTEGER;
  230.                         END;
  231.                                    (* Saves stack of CALLed scripts *)
  232.                                    
  233.    Script_Call_Stack_Type = RECORD
  234.                                Proc_Param  : Script_Parameter_Ptr;
  235.                                Proc_Got    : INTEGER;
  236.                                Proc_Count  : INTEGER;
  237.                                Return_Addr : INTEGER;
  238.                                Save_Vars   : Script_Save_Variable_Record_Ptr;
  239.                             END;
  240.  
  241.                                    (* Search order for scripts *)
  242.                                    
  243.    Script_Search_Order_Type = ( Dir_Then_Lib, Lib_Then_Dir, Dir_Only, Lib_Only );
  244.    
  245.    
  246.                                    (* Stack entry for script execution *)
  247.    Stack_Entry = RECORD
  248.                     TypVal : OperandType;
  249.                     IntVal : INTEGER;
  250.                     StrVal : AnyStr;
  251.                  END;
  252.                  
  253.    Stack_Entry_Ptr = ^Stack_Entry;
  254.  
  255.    Script_When_Record = RECORD
  256.                            When_Found: BOOLEAN;
  257.                            When_Text : StringPtr;
  258.                            Reply_Text: StringPtr;
  259.                         END;
  260.                         
  261.    Script_Wait_Record = RECORD
  262.                            Wait_Text : StringPtr;
  263.                            Wait_Reply: StringPtr;
  264.                         END;
  265.                         
  266.    Script_File_Record = RECORD
  267.                            ReadOnly : BOOLEAN;
  268.                            Opened   : BOOLEAN;
  269.                            EOF_Seen : BOOLEAN;
  270.                            F        : Text_File;
  271.                         END;
  272.                         
  273.    Script_File_Record_Ptr  = ^Script_File_Record;
  274.    
  275.    
  276. VAR
  277.                                    (* Index of currently executing script *)
  278.    Current_Script_Num     : INTEGER;
  279.  
  280.                                    (* WHEN text to wait for *)
  281.    Script_When_Text       : AnyStr;
  282.  
  283.                                    (* Response text for WHEN *)
  284.    Script_When_Reply_Text : AnyStr;
  285.  
  286.                                    (* Response text for WHENDROP *)
  287.    Script_When_Drop_Text  : AnyStr;
  288.  
  289.                                    (* Current input for WHEN checking *)
  290.    Script_When_Save       : AnyStr;
  291.  
  292.                                    (* Current input for WAITSTRING checking *)
  293.    Script_Wait_Save       : AnyStr;
  294.  
  295.                                    (* # of characters to wait for *)
  296.    Script_Wait_Char_Count : INTEGER;
  297.  
  298.                                    (* # of 1/100 secs to wait quiet *)
  299.    Script_WaitQuiet_Time  : REAL;
  300.  
  301.                                    (* Time to wait for input string     *)
  302.    Script_Wait_Time       : INTEGER;
  303.  
  304.                                    (* Default time to wait for input string *)
  305.                                    
  306.    Script_Default_Wait_Time : INTEGER;
  307.    
  308.                                    (* Starting time of day for wait         *)
  309.    Script_Wait_Start      : REAL;
  310.    
  311.                                    (* Where to go to if wait string fails   *)
  312.    Script_Wait_Failure    : INTEGER;
  313.    
  314.                                    (* Wait string appeared                  *)
  315.    Script_Wait_Found      : BOOLEAN;
  316.  
  317.                                    (* Size of script buffer                 *)
  318.                                    
  319.    Script_Buffer_Size     : INTEGER;
  320.    
  321.                                    (* Pointer to compiled script text       *)
  322.                                    
  323.    Script_Buffer          : Script_Buffer_Ptr;
  324.  
  325.                                    (* Current position in script buffer     *)
  326.  
  327.    Script_Buffer_Pos      : INTEGER;
  328.  
  329.                                    (* Script integer values             *)
  330.  
  331.    Script_Integer_1       : INTEGER;
  332.    Script_Integer_2       : INTEGER;
  333.    Script_Integer_3       : INTEGER;
  334.    Script_Integer_4       : INTEGER;
  335.  
  336.                                    (* Script text values                *)
  337.  
  338.    Script_String          : AnyStr;
  339.    Script_String_2        : AnyStr;
  340.    Script_String_3        : AnyStr;
  341.    Script_String_4        : AnyStr;
  342.  
  343.                                    (* Reply to Script INPUT prompt      *)
  344.    Script_Reply           : AnyStr;
  345.    
  346.                                    (* Reply was OK                      *)
  347.    Script_Reply_Found     : BOOLEAN;
  348.    
  349.                                    (* Script suspend time period        *)
  350.    Script_Suspend_Time    : REAL;
  351.    
  352.                                    (* Script suspend starting time      *)
  353.    Script_Suspend_Start   : REAL;
  354.    
  355.                                    (* Reply to Script RINPUT prompt     *)
  356.    Script_Remote_Reply    : AnyStr;
  357.    
  358.                                    (* Reply was OK                      *)
  359.    Script_Remote_Reply_OK : BOOLEAN;
  360.    
  361.                                    (* Marker for parameter substitution *)
  362.    Script_Parameter_Marker: CHAR;
  363.    
  364.                                    (* Scripts compiled and loaded       *)
  365.                                    
  366.    Scripts                : ARRAY[1..MaxScripts] OF Script_Record_Type;
  367.    
  368.                                    (* Number of compiled scripts        *)
  369.                                    
  370.    Script_Count           : 0..MaxScripts;
  371.    
  372.                                    (* Script variables                  *)
  373.                                    
  374.    Script_Variables       : Script_Variable_List_Ptr;
  375.  
  376.                                    (* Number of script variables active *)
  377.                                    
  378.    Script_Variable_Count  : 0..MaxScriptVariables;
  379.    
  380.                                    (* Script parameter variables        *)
  381.  
  382.    Script_Parameters      : Script_Parameter_Ptr;
  383.    
  384.                                    (* Number of script parameters active *)
  385.  
  386.    Script_Parameter_Count : 0..MaxScriptVariables;
  387.    Script_Parameter_Got   : 0..MaxScriptVariables;
  388.    
  389.                                    (* Previous script's variables *)
  390.                                    
  391.    Prev_Script_Variables  : Script_Variable_List_Ptr;
  392.    
  393.                                    (* Save positions in nested scripts  *)
  394.  
  395.    Script_Stack_Position  : ARRAY[0..MaxNestedScripts] OF Script_Buffer_Save;
  396.    Script_Stack_Depth     : 0..MaxNestedScripts;
  397.  
  398.                                    (* Save positions in script procedures *)
  399.  
  400.    Script_Call_Stack     : ARRAY[0..MaxScriptCalls] OF Script_Call_Stack_Type;
  401.    Script_Call_Depth     : 0..MaxScriptCalls;
  402.  
  403.                                    (* Procedure parameter variables *)
  404.  
  405.    Proc_Parameters       : Script_Parameter_Ptr;
  406.  
  407.                                    (* Number of script parameters active *)
  408.  
  409.    Proc_Parameter_Count  : 0..MaxScriptVariables;
  410.    Proc_Parameter_Got    : 0..MaxScriptVariables;
  411.  
  412.                                    (* Learn variables *)
  413.  
  414.    Script_Learn_Buffer_Size : INTEGER (* Learning buffer size *);
  415.    Script_Learn_Lines       : INTEGER (* Max. # of successive WaitStrings *);
  416.    Script_Learn_Line_Count  : INTEGER (* Count of WaitStrings generated   *);
  417.    Script_Wait_Generated    : BOOLEAN (* TRUE if WaitString generated     *);
  418.  
  419.                                    (* Search order type *)
  420.  
  421.    Script_Search_Order      : Script_Search_Order_Type;
  422.  
  423.                                    (* Vector of WHEN strings *)
  424.  
  425.    Script_When_List         : ARRAY[1..MaxWhenStrings] OF Script_When_Record;
  426.    Script_When_Count        : 0..MaxWhenStrings;
  427.  
  428.                                    (* Vector of WAIT strings *)
  429.  
  430.    Script_Wait_List         : ARRAY[1..MaxWaitStrings] OF Script_Wait_Record;
  431.  
  432.                                    (* # of active waitstrings *)
  433.                                    
  434.    Script_Wait_Count        : 0..MaxWaitStrings;
  435.    
  436.                                    (* Variable to receive wait index *)
  437.                                    
  438.    Script_Wait_Result_Index : INTEGER;
  439.    
  440.                                    (* # chars to save for wait check *)
  441.                                    
  442.    Script_Wait_Check_Length : INTEGER;
  443.    
  444.                                    (* Vector of files for use in scripts *)
  445.  
  446.    Script_File_List         : ARRAY[0..MaxScriptOpenFiles] OF Script_File_Record_Ptr;
  447.    
  448.                                    (* If given file used in script *)
  449.                                    
  450.    Script_File_Used         : ARRAY[0..MaxScriptOpenFiles] OF BOOLEAN;
  451.  
  452.                                    (* # of files opened in script *)
  453.  
  454.    Script_File_Count        : 0..MaxScriptOpenFiles;
  455.    
  456.    Script_IO_Error          : INTEGER    (* I/O error in script *);
  457.    
  458.                                    (* User-defined commands *)
  459.                                    
  460.    Script_New_Commands      : ARRAY[1..MaxNewCommands] OF STRING[8];
  461.    Script_New_Command_Count : INTEGER;
  462.    
  463.                                    (* TRUE if executing command key script *)
  464.                                    
  465.    Script_Command_Key_Mode  : BOOLEAN;
  466.  
  467. (*----------------------------------------------------------------------*)
  468. (*                    Command line mode variables                       *)
  469. (*----------------------------------------------------------------------*)
  470.  
  471. VAR
  472.    Command_Key      : INTEGER      (* Function which invokes command  *);
  473.    Command_Key_Name : STRING[20]   (* Command key name                *);
  474.    Command_Key_Text : AnyStr       (* Text of command line            *);
  475.    Use_Prev_Key_Text: BOOLEAN      (* TRUE to use prev. text to start *);
  476.  
  477. (*----------------------------------------------------------------------*)
  478. (*                 Global error return from DOS                         *)
  479. (*----------------------------------------------------------------------*)
  480.  
  481. VAR
  482.    Ierr : INTEGER                  (* DOS return error *);
  483.    
  484. (*----------------------------------------------------------------------*)
  485. (*                 Global screen positioning for autodownloads          *)
  486. (*----------------------------------------------------------------------*)
  487.  
  488. VAR
  489.    NewX  : INTEGER;
  490.    OldX  : INTEGER;
  491.    NewY  : INTEGER;
  492.    OldY  : INTEGER;
  493.    
  494. (*----------------------------------------------------------------------*)
  495. (*                    Gossip mode definitions screen                    *)
  496. (*----------------------------------------------------------------------*)
  497.  
  498. VAR
  499.    Gossip_Window_Size : INTEGER    (* Number of lines in top window *);
  500.    Gossip_Line_Mode   : BOOLEAN    (* TRUE if line-edit GOSSIP mode *);
  501.    
  502. (*----------------------------------------------------------------------*)
  503. (*                           Session timers                             *)
  504. (*----------------------------------------------------------------------*)
  505.  
  506. VAR
  507.    Session_Start_Time: REAL        (* Starting time of entire session *);
  508.    Dialing_Start_Time: REAL        (* Starting time current dialing   *);
  509.    
  510. (*----------------------------------------------------------------------*)
  511. (*                   Global graphics positions                          *)
  512. (*----------------------------------------------------------------------*)
  513.  
  514. VAR
  515.    Graphics_XPos: INTEGER;
  516.    Graphics_YPos: INTEGER;
  517.  
  518. CONST
  519.    INT24Err     : BOOLEAN = FALSE;
  520.    INT24ErrCode : BYTE    = 0;
  521.    OldINT24     : ARRAY[1..2] OF INTEGER = ( 0 , 0 );
  522.    
  523. VAR
  524.    RegisterSet : RegPack;
  525.    
  526. (*----------------------------------------------------------------------*)
  527. (*                                                                      *)
  528. (*                  COMMUNICATIONS HARDWARE ADDRESSES                   *)
  529. (*                                                                      *)
  530. (*        These are specific to IBM PCs and close compatibles.          *)
  531. (*                                                                      *)
  532. (*----------------------------------------------------------------------*)
  533.  
  534. CONST
  535.  
  536.    UART_THR = $00;       (* offset from base of UART Registers for IBM PC *)
  537.    UART_RBR = $00;
  538.    UART_IER = $01;
  539.    UART_IIR = $02;
  540.    UART_LCR = $03;
  541.    UART_MCR = $04;
  542.    UART_LSR = $05;
  543.    UART_MSR = $06;
  544.  
  545.    I8088_IMR = $21;      (* port address of the Interrupt Mask Register *)
  546.    
  547.    COM1_Base = $03F8;    (* port addresses for the UART *)
  548.    COM2_Base = $02F8;
  549.    COM3_Base = $03E8;
  550.    COM4_Base = $02E8;
  551.    
  552.    COM1_Irq = 4;         (* Interrupt line for the UART *)
  553.    COM2_Irq = 3;
  554.    COM3_Irq = 4;
  555.    COM4_Irq = 3;
  556.    
  557.    COM1_RS232 = $F8;     (* RS 232 base pointers for UART *)
  558.    COM2_RS232 = $F8;
  559.    COM3_RS232 = $E8;
  560.    COM4_RS232 = $E8;
  561.  
  562.    RS232_Base = $0400    (* Address of RS 232 com port pointer *);
  563.  
  564.    MaxComPorts = 4       (* Four ports allowed by this code    *);
  565.    
  566. CONST
  567.  
  568.    Async_DSeg_Save : INTEGER = 0;  (* Save DS reg in Code Segment for *)
  569.                                    (* interrupt routine               *)
  570.                                    
  571. (*----------------------------------------------------------------------*)
  572. (*                                                                      *)
  573. (*                   COMMUNICATIONS BUFFER VARIABLES                    *)
  574. (*                                                                      *)
  575. (*     The Communications Buffer is implemented as a circular (ring)    *)
  576. (*     buffer, or double-ended queue.  The asynchronous I/O routines    *)
  577. (*     enter characters in the buffer as they are received.  Higher-    *)
  578. (*     level routines may extract characters from the buffer.           *)
  579. (*                                                                      *)
  580. (*     Note that this buffer is used for input only;  output is done    *)
  581. (*     on a character-by-character basis.                               *)
  582. (*                                                                      *)
  583. (*----------------------------------------------------------------------*)
  584.  
  585. CONST
  586.  
  587.    TimeOut             = 256        (* TimeOut value                   *);
  588.    Async_XON           = ^Q         (* XON character                   *);
  589.    Async_XOFF          = ^S         (* XOFF character                  *);
  590.  
  591.    Async_Overrun_Error = 2          (*   overrun                       *);
  592.    Async_Parity_Error  = 4          (*   parity error                  *);
  593.    Async_Framing_Error = 8          (*   framing error                 *);
  594.    Async_Break_Found   = 16         (*   break interrupt               *);
  595.    
  596.    Async_CTS           = $10        (*   Clear to send                 *);
  597.    Async_DSR           = $20        (*   Data set ready                *);
  598.    
  599. TYPE
  600.    Async_Buffer_Type   = ARRAY[0..1] OF CHAR;
  601.    Async_Ptr           = ^Async_Buffer_Type;
  602.    
  603.    
  604. VAR                                 (* Port addresses for serial ports *)
  605.    Com_Base               : ARRAY[1..MaxComPorts] OF INTEGER;
  606.    
  607.                                     (* IRQ line for each serial port   *)
  608.    Com_Irq                : ARRAY[1..MaxComPorts] OF INTEGER;
  609.  
  610.                                     (* RS 232 addresses for each port  *)
  611.    Com_RS232              : ARRAY[1..MaxComPorts] OF INTEGER;
  612.    
  613.                                    (* Default addresses of each com port *)
  614.                                    
  615.    Default_Com_Base       : ARRAY[1..MaxComPorts] OF INTEGER;
  616.    
  617.                                    (* Default IRQ line for each port *)
  618.                                    
  619.    Default_Com_Irq        : ARRAY[1..MaxComPorts] OF INTEGER;
  620.    
  621.                                    (* Default RS232 base addresses of each port *)
  622.                                    
  623.    Default_Com_RS232      : ARRAY[1..MaxComPorts] OF INTEGER;
  624.    
  625. VAR
  626.    Async_Buffer_Ptr       : Async_Ptr  (* Input buffer address  *);
  627.    Async_OBuffer_Ptr      : Async_Ptr  (* Output buffer address *);
  628.    
  629.    Async_Open_Flag        : BOOLEAN    (* true if port opened               *);
  630.    Async_Port             : INTEGER    (* current open port number (1 -- 4) *);
  631.    Async_Base             : INTEGER    (* base for current open port        *);
  632.    Async_Irq              : INTEGER    (* IRQ for current open port         *);
  633.    Async_RS232            : INTEGER    (* RS232 address for current port    *);
  634.    
  635.    Async_Buffer_Overflow  : BOOLEAN    (* True if buffer overflow has happened *);
  636.    Async_Buffer_Used      : INTEGER    (* Amount of input buffer used so far   *);
  637.    Async_MaxBufferUsed    : INTEGER    (* Maximum amount of input buffer used  *);
  638.    
  639.                                        (* Async_Buffer empty if Head = Tail    *)
  640.    Async_Buffer_Head      : INTEGER    (* Loc in Async_Buffer to put next char *);
  641.    Async_Buffer_Tail      : INTEGER    (* Loc in Async_Buffer to get next char *);
  642.  
  643.    Async_OBuffer_Overflow : BOOLEAN    (* True if buffer overflow has happened *);
  644.    Async_OBuffer_Used     : INTEGER    (* Amount of output buffer used         *);
  645.    Async_MaxOBufferUsed   : INTEGER    (* Max amount of output buffer used     *);
  646.  
  647.                                        (* Async_Buffer empty if Head = Tail    *)
  648.    Async_OBuffer_Head     : INTEGER    (* Loc in Async_Buffer to put next char *);
  649.    Async_OBuffer_Tail     : INTEGER    (* Loc in Async_Buffer to get next char *);
  650.  
  651.    Async_Buffer_Low       : INTEGER    (* Low point in receive buffer for XON  *);
  652.    Async_Buffer_High      : INTEGER    (* High point in receive buffer for XOFF*);
  653.    Async_Buffer_High_2    : INTEGER    (* Emergency point for XOFF             *);
  654.    
  655.    Async_XOFF_Sent        : BOOLEAN    (* If XOFF sent                      *);
  656.    Async_XOFF_Received    : BOOLEAN    (* If XOFF received                  *);
  657.    Async_XOFF_Rec_Display : BOOLEAN    (* If XOFF received                  *);
  658.    Async_XON_Rec_Display  : BOOLEAN    (* If XOFF received                  *);
  659.    Async_Baud_Rate        : INTEGER    (* Current baud rate                 *);
  660.    
  661.                                     (* Save previous serial interrupt status *)
  662.    Async_Save_IAddr       : ARRAY[1..2] OF INTEGER;
  663.    Async_Do_CTS           : BOOLEAN (* TRUE to do clear-to-send checking    *);
  664.    Async_Do_DSR           : BOOLEAN (* TRUE to do data-set-ready checking   *);
  665.    Async_Do_XonXoff       : BOOLEAN (* TRUE to do XON/XOFF flow checking    *);
  666.    Async_Hard_Wired_On    : BOOLEAN (* TRUE if hard-wired connection        *);
  667.    Async_Break_Length     : INTEGER (* Length of break in 1/10 seconds      *);
  668.    Async_Line_Status      : BYTE    (* Line Status Reg at interrupt         *);
  669.    Async_Modem_Status     : BYTE    (* Modem Status Reg at interrupt        *);
  670.    Async_Line_Error_Flags : BYTE    (* Line status bits accumulated         *);
  671.    Async_Buffer_Size      : INTEGER (* Stores input buffer size             *);
  672.    Async_OBuffer_Size     : INTEGER (* Stores output buffer size            *);
  673.    Async_Uart_IER         : INTEGER (* Interrupt enable register address    *);
  674.    Async_Uart_IIR         : INTEGER (* Interrupt ID register address        *);
  675.    Async_Uart_MSR         : INTEGER (* Modem status register address        *);
  676.    Async_Uart_LSR         : INTEGER (* Line status register address         *);
  677.    Async_Send_XOFF        : BOOLEAN (* TRUE to send XOFF ASAP               *);
  678.    Async_Send_Address     : INTEGER (* Address of async send routine        *);
  679.    Async_Output_Delay     : INTEGER (* Delay in ms when output buffer full  *);
  680.    Async_OneMSDelay       : INTEGER (* Loop count value to effect 1 ms delay*);
  681.    
  682. VAR
  683.    Async_Buffer_Length    : INTEGER (* Receive buffer length                *);
  684.    Async_OBuffer_Length   : INTEGER (* Send buffer length                   *);
  685.    
  686. (*----------------------------------------------------------------------*)
  687. (*          Definitions for screen memory reading/writing               *)
  688. (*----------------------------------------------------------------------*)
  689.  
  690. CONST
  691.    Color_Screen_Address   = $B800    (* Address of color screen          *);
  692.    Mono_Screen_Address    = $B000    (* Address of mono screen           *);
  693.    Screen_Length          = 4000     (* 80 x 25 x 2 = screen area length *);
  694.    Graphics_Screen_Length = 16000    (* Length of graphics screen area   *);
  695.    Max_Saved_Screen       = 6        (* Maximum no. of saved screens     *);
  696.    MedRes_GraphMode       = 4        (* Medium resolution graphics       *);
  697.    HiRes_GraphMode        = 6        (* High resolution graphics mode    *);
  698.    Mono_TextMode          = 7        (* Monochrome adapter text mode     *);
  699.    CRT_Index              = $03D4    (* CRT index register               *);
  700.    CRT_Data               = $03D5    (* CRT data register                *);
  701.    CRT_Mode               = $03D8    (* CRT mode register                *);
  702.    CRT_Color_Select       = $03D9    (* CRT color select register        *);
  703.    CRT_Status             = $03DA    (* CRT status port                  *);
  704.    CRT_Mode_Byte          = $0465    (* CRT mode byte                    *);
  705.    Turbo_Screen_Width     = $016A    (* Where Turbo stores screen width  *);
  706.    Turbo_Screen_Length    = $016B    (* Where Turbo stores screen length *);
  707.  
  708. TYPE
  709.                                      (* A screen image            *)
  710.                                      
  711.    Screen_Type       = ARRAY[ 1 .. Graphics_Screen_Length ] OF BYTE;
  712.    
  713.    Screen_Ptr        = ^Screen_Image_Type;
  714.    
  715.    Screen_Image_Type = RECORD
  716.                           Screen_Image: Screen_Type;
  717.                        END;
  718.                        
  719.                                               (* Screen stack entries      *)
  720.    Saved_Screen_Ptr  = ^Saved_Screen_Type;
  721.    
  722.    Saved_Screen_Type = RECORD
  723.                           Screen_Row    : INTEGER;
  724.                           Screen_Column : INTEGER;
  725.                           Screen_X1     : INTEGER;
  726.                           Screen_Y1     : INTEGER;
  727.                           Screen_X2     : INTEGER;
  728.                           Screen_Y2     : INTEGER;
  729.                           Window_X1     : INTEGER;
  730.                           Window_Y1     : INTEGER;
  731.                           Window_X2     : INTEGER;
  732.                           Window_Y2     : INTEGER;
  733.                           Screen_Size   : INTEGER;
  734.                           Video_Mode    : INTEGER;
  735.                           If_BIOS       : BOOLEAN;
  736.                           Screen_Image  : Screen_Type;
  737.                        END;
  738.  
  739. CONST
  740.    Video_Interrupt  = $10          (* Video interrupt number     *);
  741.  
  742. CONST                              (* Save previous video interrupt status. *)
  743.                                    (* Note:  THESE MUST BE IN CODE SEGMENT! *)
  744.  
  745.    Video_Save_Iaddr2 : INTEGER = 0;
  746.    Video_Save_Iaddr1 : INTEGER = 0;
  747.  
  748.    Video_Request     : INTEGER = 0     (* Current video request *);
  749.    Video_Fill        : INTEGER = 0     (* Fill attribute        *);
  750.    Video_Page        : BYTE    = 0     (* Text memory page      *);
  751.    Video_Mode        : BYTE    = 3     (* Current text mode     *);
  752.    Video_Screen_Addr : INTEGER = $B800 (* Screen memory address *);
  753.  
  754. VAR
  755.  
  756.    Max_Screen_Col       : INTEGER             (* PC's screen width         *);
  757.    Wrap_Screen_Col      : INTEGER             (* Column at which to wrap   *);
  758.    
  759.    Max_Screen_Line      : INTEGER             (* PC's screen length        *);
  760.    
  761.                                               (* Memory-mapped screen area *)
  762.    Actual_Screen        : Screen_Ptr;
  763.                                               (* Saves screen behind menus *)
  764.                                               
  765.    Saved_Screen         : Saved_Screen_Ptr;
  766.    
  767.                                               (* Stack of saved screens    *)
  768.  
  769.    Saved_Screen_List    : ARRAY[ 1 .. Max_Saved_Screen ] OF Saved_Screen_Ptr;
  770.    
  771.                                               (* Depth of saved screen stack *)
  772.    Current_Saved_Screen : 0 .. Max_Saved_Screen;
  773.    
  774.                                    (* Upper left corner of      *)
  775.                                    (* current TURBO window      *)
  776. VAR
  777.    Upper_Left_Column  : INTEGER;
  778.    Upper_Left_Row     : INTEGER;
  779.    
  780.                                    (* Lower right corner of     *)
  781.                                    (* current TURBO window      *)
  782. VAR
  783.    Lower_Right_Column  : INTEGER;
  784.    Lower_Right_Row     : INTEGER;
  785.    
  786. VAR
  787.    Global_ForeGround_Color : INTEGER;
  788.    Global_BackGround_Color : INTEGER;
  789.    Global_Border_Color     : INTEGER;
  790.    Global_Text_Attribute   : INTEGER;
  791.  
  792. (*----------------------------------------------------------------------*)
  793. (*                       Multitasker definitions                        *)
  794. (*----------------------------------------------------------------------*)
  795.  
  796. TYPE
  797.    MultiTaskerType     = ( MultiTasker_None, DoubleDos, DesqView, TopView,
  798.                            MSWindows, APXCore, EZDosIt, Concurrent_DOS,
  799.                            TaskView, MultiLink, Other );
  800.                            
  801. VAR
  802.    TimeSharingActive   : BOOLEAN   (* TRUE if multitasker active        *);
  803.  
  804.                                    (* Which multitasker active          *)
  805.    MultiTasker         : MultiTaskerType;
  806.    
  807.    DesqView_Screen     : Screen_Ptr (* Alternate display buffer address *);
  808.    Graphics_Screen     : Screen_Ptr (* Graphics display buffer address  *);
  809.    
  810. (*----------------------------------------------------------------------*)
  811. (*                   Menu constants, types, and variables               *)
  812. (*----------------------------------------------------------------------*)
  813.  
  814. CONST
  815.  
  816.    Up_arrow         = ^E;    (* move up in menu code   *)
  817.    Down_arrow       = ^X;    (* move down in menu code *)
  818.    Space_bar        = #32;   (* space bar              *)
  819.    Ch_cr            = #13;   (* Carriage return *)
  820.    Ch_esc           = #27;   (* Escape *)
  821.    Ch_bell          = #07;   (* Bell *)
  822.    
  823.    Max_Menu_Items   = 21;    (* Maximum number of menu choices *)
  824.    
  825.    Dont_Erase_Menu  = FALSE;
  826.    Erase_Menu       = TRUE;
  827.    
  828. TYPE
  829.  
  830.    String40   = STRING[40]         (* Menu entry string type               *);
  831.    String80   = STRING[80]         (* Menu title string type               *);
  832.    
  833.    Menu_Entry = RECORD
  834.       Menu_Item_Text   : String40; (* Text of entry                        *)
  835.       Menu_Item_Row    : BYTE;     (* Row position of menu item            *)
  836.       Menu_Item_Column : BYTE;     (* Column position of menu item         *)
  837.    END;
  838.  
  839.    Menu_Type = RECORD
  840.       Menu_Size     : 1 .. Max_Menu_Items;    (* No. of items in menu      *)
  841.       Menu_Title    : String80;               (* Menu title                *)
  842.       Menu_Row      : BYTE;                   (* Row position of menu      *)
  843.       Menu_Column   : BYTE;                   (* Column position of menu   *)
  844.       Menu_Width    : BYTE;                   (* Width of menu             *)
  845.       Menu_Height   : BYTE;                   (* Height of menu            *)
  846.       Menu_Default  : 1 .. Max_Menu_Items;    (* Default value position    *)
  847.       Menu_TColor   : BYTE;                   (* Foreground text color     *)
  848.       Menu_BColor   : BYTE;                   (* BackGround color          *)
  849.       Menu_FColor   : BYTE;                   (* Frame color               *)
  850.       Menu_HColor   : BYTE;                   (* Title color               *)
  851.                                               (* Menu items themselves     *)
  852.       Menu_Entries  : ARRAY[ 1 .. Max_Menu_Items ] Of Menu_Entry;
  853.    END;
  854.    
  855. VAR
  856.    Menu_Explode_Mode : BOOLEAN     (* TRUE to use exploding menus *);
  857.    Menu_Beep_Mode    : BOOLEAN     (* TRUE to beep on errors      *);
  858.    Menu_Depth        : INTEGER     (* Depth of current menus      *);
  859.    
  860. VAR
  861.                                    (* Box-drawing characters for menus *)
  862.    Menu_Box_Chars : RECORD
  863.                        Top_Left_Corner     : CHAR;
  864.                        Top_Line            : CHAR;
  865.                        Top_Right_Corner    : CHAR;
  866.                        Right_Line          : CHAR;
  867.                        Bottom_Right_Corner : CHAR;
  868.                        Bottom_Line         : CHAR;
  869.                        Bottom_Left_Corner  : CHAR;
  870.                        Left_Line           : CHAR;
  871.                     END;
  872.                     
  873.                                    (* For MENU command *)
  874.    Script_Menu_Holder : ^Menu_Type;
  875.    
  876. (*----------------------------------------------------------------------*)
  877. (*                  Map of MsDos Directory Entry                        *)
  878. (*----------------------------------------------------------------------*)
  879.  
  880. TYPE
  881.  
  882.    Directory_Record = RECORD
  883.                          Filler    : ARRAY[1..21] Of BYTE;
  884.                          File_Attr : BYTE;
  885.                          File_Time : INTEGER;
  886.                          File_Date : INTEGER;
  887.                          File_Size : ARRAY[1..2] Of INTEGER;
  888.                          File_Name : ARRAY[1..80] Of CHAR;
  889.                       END;
  890.  
  891. CONST
  892.    Dir_Attr_Read_Only    =  1;
  893.    Dir_Attr_Hidden       =  2;
  894.    Dir_Attr_System       =  4;
  895.    Dir_Attr_Volume_Label =  8;
  896.    Dir_Attr_Subdirectory = 16;
  897.    Dir_Attr_Archive      = 32;
  898.    
  899.    Access_Read_Mode           = 0;
  900.    Access_Write_Mode          = 1;
  901.    Access_Read_And_Write_Mode = 2;
  902.    
  903.    Attribute_None             = 0;
  904.    Attribute_Read_Only        = 1;
  905.    Attribute_Hidden           = 2;
  906.    Attribute_System           = 4;
  907.    Attribute_Volume_Label     = 8;
  908.    Attribute_Subdirectory     = 16;
  909.    Attribute_Archive          = 32;
  910.    
  911. VAR                                (* Easier addressing in INLINE *)
  912.    Global_Crc : INTEGER;
  913.  
  914. VAR                                (* DOS error flag              *)
  915.    Err: INTEGER;
  916.    
  917. VAR
  918.                                    (* Saves screen in batch transfers *)
  919.                                    
  920.    Batch_Screen_Ptr   : Saved_Screen_Ptr;
  921.    Kermit_Local_Save  : Saved_Screen_Ptr (* Saves screen for Kermit  *);
  922.    
  923. (*----------------------------------------------------------------------*)
  924. (*              Initialization/Parameter resetting variables            *)
  925. (*----------------------------------------------------------------------*)
  926.  
  927. VAR                                (* Hold new colors/video mode *)
  928.    New_Text_Mode          : INTEGER;
  929.    New_ForeGround_Color   : INTEGER;
  930.    New_BackGround_Color   : INTEGER;
  931.    New_Menu_Text_Color    : INTEGER;
  932.    New_Menu_Title_Color   : INTEGER;
  933.    New_Menu_Frame_Color   : INTEGER;
  934.    New_Border_Color       : INTEGER;
  935.    New_Menu_Text_Color_2  : INTEGER;
  936.    Review_Buffer_Length   : INTEGER;
  937.    Last_Line_To_Set       : INTEGER;
  938.    Kbd_Interrupt_Change   : BOOLEAN;
  939.    Video_Interrupt_Change : BOOLEAN;
  940.  
  941. (*----------------------------------------------------------------------*)
  942. (*                     DOS jump interface variables                     *)
  943. (*----------------------------------------------------------------------*)
  944.  
  945. CONST                              (* DO NOT REDUCE *)
  946.    NewStackSize    = 1700            (* Stack size to keep while in DOS shell (>700) *);
  947.    MinDOSspace     = 20000           (* Min bytes for DOS shell to run *);
  948.    StackBufferSize = MaxSectorLength (* Bytes in DOS stack buffer      *);
  949.    
  950. VAR
  951.    TopOfStack  : INTEGER;
  952.    StackBuffer : ARRAY[1..StackBufferSize] OF BYTE ABSOLUTE Sector_Data;
  953.    StackSeg    : INTEGER;
  954.    StackPtr    : INTEGER;
  955.    NewStackSeg : INTEGER;
  956.    NewStackPtr : INTEGER;
  957.    ParasToKeep : INTEGER;
  958.    ParasWeHave : INTEGER;
  959.    ParasForDos : INTEGER;
  960.    ExecStatus  : INTEGER;
  961.    CommandStr  : AnyStr;
  962.    Error_Found : BOOLEAN;
  963.    
  964. (*----------------------------------------------------------------------*)
  965. (*                     Module Interface Vectors                         *)
  966. (*----------------------------------------------------------------------*)
  967.  
  968. CONST
  969.    MainModule = 0;
  970.    PT4TERM    = 1;
  971.    PT4KERM    = 2;
  972.    PT4XMOD    = 3;
  973.    PT4EDIT    = 4;
  974.    PT4HOST    = 5;
  975.    PT4USER    = 6;
  976.    PT4DIAL    = 7;
  977.    PT4SCRI    = 8;
  978.    PT4SETP    = 9;
  979.    PT4INIT    = 10;
  980.    PT4UTIL    = 11;
  981.    PT4T4010   = 12;
  982.    PT4GOSSI   = 13;
  983.  
  984.    MaxNumModules = 20;
  985.    MaxStackSize  = 255;
  986.    
  987. VAR                                (* Overlay section if a module is *)
  988.                                    (* already loaded                 *)
  989.                                    
  990.    ModuleLoaded: ARRAY[1..MaxNumModules] OF INTEGER;
  991.  
  992. (*----------------------------------------------------------------------*)
  993. (*             Overlay section definitions (NOT standard Extender)      *)
  994. (*----------------------------------------------------------------------*)
  995.  
  996. CONST
  997.    MaxNumOverlays = 3              (* Number of overlays *);
  998.  
  999. TYPE
  1000.                                    (* Holds info describing module *)
  1001.                                    (* overlay areas                *)
  1002.    PointerType       = ^INTEGER;
  1003.  
  1004.    OverlayAreaRecord = RECORD
  1005.                           Pointer       : PointerType;
  1006.                           Size          : INTEGER;
  1007.                           OverlaySeg    : INTEGER;
  1008.                           CurrentModule : INTEGER;
  1009.                        END;
  1010.  
  1011. VAR
  1012.                                     (* Holds descriptive information    *)
  1013.                                     (* regarding reserved overlay areas *)
  1014.                                     
  1015.    OverlayArea      : ARRAY[0..MaxNumOverlays] OF OverlayAreaRecord;
  1016.    
  1017.    LoadingOverlay   : BOOLEAN       (* TRUE if loading overlay *);
  1018.    GlobalOverlayNum : INTEGER       (* Overlay section being loaded into *);
  1019.  
  1020. (*----------------------------------------------------------------------*)
  1021. (*                     Forward declarations                             *)
  1022. (*----------------------------------------------------------------------*)
  1023.  
  1024. PROCEDURE WriteSXY( S: AnyStr; X: INTEGER; Y: INTEGER; Color: INTEGER );
  1025.    FORWARD;
  1026.    
  1027. FUNCTION DateString : AnyStr;
  1028.    FORWARD;
  1029.  
  1030. {.C+}
  1031.